// Package service 领域服务包，包含核心业务逻辑的实现
package service

import (
    "context"
    "errors"
    "windsurf-project/internal/domain/entity"
    "windsurf-project/internal/domain/repository"
)

// UserDomainService 用户领域服务
// 负责处理用户相关的核心业务逻辑
type UserDomainService struct {
    userRepo repository.UserRepository // userRepo 用户仓储接口
}

// NewUserDomainService 创建新的用户领域服务实例
func NewUserDomainService(userRepo repository.UserRepository) *UserDomainService {
    return &UserDomainService{
        userRepo: userRepo,
    }
}

// ValidateUser 验证用户信息的有效性
// 检查用户名、邮箱和密码是否为空
func (s *UserDomainService) ValidateUser(user *entity.User) error {
    if user.Username == "" {
        return errors.New("用户名不能为空")
    }
    if user.Email == "" {
        return errors.New("邮箱不能为空")
    }
    if user.Password == "" {
        return errors.New("密码不能为空")
    }
    return nil
}

// CreateUser 创建新用户
// 验证用户信息并调用仓储层创建用户
func (s *UserDomainService) CreateUser(ctx context.Context, user *entity.User) error {
    if err := s.ValidateUser(user); err != nil {
        return err
    }
    return s.userRepo.Create(ctx, user)
}

// GetUser 获取用户信息
// 根据用户ID获取用户详细信息
func (s *UserDomainService) GetUser(ctx context.Context, id uint) (*entity.User, error) {
    if id == 0 {
        return nil, errors.New("无效的用户ID")
    }
    return s.userRepo.GetByID(ctx, id)
}

// UpdateUser 更新用户信息
// 验证并更新指定用户的信息
func (s *UserDomainService) UpdateUser(ctx context.Context, user *entity.User) error {
    if user.ID == 0 {
        return errors.New("用户ID不能为空")
    }
    
    // Check if user exists
    existingUser, err := s.userRepo.GetByID(ctx, user.ID)
    if err != nil {
        return err
    }
    if existingUser == nil {
        return errors.New("用户不存在")
    }

    // Validate updated fields
    if user.Username == "" {
        user.Username = existingUser.Username
    }
    if user.Email == "" {
        user.Email = existingUser.Email
    }
    
    // Keep the original password if not updated
    if user.Password == "" {
        user.Password = existingUser.Password
    }

    return s.userRepo.Update(ctx, user)
}

// DeleteUser 删除用户
// 根据用户ID删除指定用户
func (s *UserDomainService) DeleteUser(ctx context.Context, id uint) error {
    if id == 0 {
        return errors.New("无效的用户ID")
    }
    
    // Check if user exists before deletion
    existingUser, err := s.userRepo.GetByID(ctx, id)
    if err != nil {
        return err
    }
    if existingUser == nil {
        return errors.New("用户不存在")
    }

    return s.userRepo.Delete(ctx, id)
}

// ListUsers 获取用户列表
// 获取系统中所有用户的列表
func (s *UserDomainService) ListUsers(ctx context.Context) ([]*entity.User, error) {
    users, err := s.userRepo.List(ctx)
    if err != nil {
        return nil, err
    }
    
    // Return empty slice instead of nil if no users found
    if users == nil {
        return []*entity.User{}, nil
    }
    
    return users, nil
}
